package tunnel

import (
	"log"

	"internal-net-bridge-server/internal/models"
	"internal-net-bridge-server/internal/tunnel/core"
)

// ========================================
// 协议监听器管理
// ========================================

// startProtocolListenerSync 同步启动协议监听器（返回错误）
func (tm *TunnelManager) startProtocolListenerSync(tunnel *models.Tunnel) error {
	log.Printf("🚀 [监听器管理] 开始启动监听器: 隧道ID=%s, 协议=%s, 端口=%s",
		tunnel.ID, tunnel.ProtocolType, tunnel.PublicPort)

	// 检查监听器是否已存在
	tm.listenerMutex.RLock()
	_, exists := tm.protocolListeners[tunnel.ID]
	tm.listenerMutex.RUnlock()

	if exists {
		log.Printf("⚠️ [监听器管理] 监听器已存在，跳过启动: 隧道ID=%s", tunnel.ID)
		return nil
	}

	// 使用协议工厂创建监听器
	listener, err := tm.protocolFactory.CreateListener(tunnel)
	if err != nil {
		log.Printf("❌ [监听器管理] 创建监听器失败: %v", err)
		return err
	}

	// 启动监听器
	if err := tm.protocolFactory.StartListener(listener); err != nil {
		log.Printf("❌ [监听器管理] 启动监听器失败: %v", err)
		return err
	}

	// 保存监听器引用
	tm.listenerMutex.Lock()
	tm.protocolListeners[tunnel.ID] = listener
	tm.listenerMutex.Unlock()

	log.Printf("✅ [监听器管理] 监听器启动成功: 隧道ID=%s, 协议=%s, 端口=%s",
		tunnel.ID, tunnel.ProtocolType, tunnel.PublicPort)

	return nil
}

// startProtocolListener 异步启动协议监听器（向后兼容）
func (tm *TunnelManager) startProtocolListener(tunnel *models.Tunnel) {
	if err := tm.startProtocolListenerSync(tunnel); err != nil {
		log.Printf("❌ [监听器管理] 监听器启动失败: %v", err)

		// 更新隧道状态为error
		if tm.tunnelService != nil {
			errorMsg := err.Error()
			if updateErr := tm.tunnelService.UpdateTunnelStatus(tunnel.ID, "error", &errorMsg); updateErr != nil {
				log.Printf("⚠️ 更新隧道状态为error失败: %v", updateErr)
			}
		}
	}
}

// stopProtocolListener 停止协议监听器
func (tm *TunnelManager) stopProtocolListener(tunnelID string) {
	tm.listenerMutex.Lock()
	listenerInterface, exists := tm.protocolListeners[tunnelID]
	if !exists {
		tm.listenerMutex.Unlock()
		log.Printf("⚠️ [监听器管理] 监听器不存在: 隧道ID=%s", tunnelID)
		return
	}
	delete(tm.protocolListeners, tunnelID)
	tm.listenerMutex.Unlock()

	// 类型断言为ProtocolListener
	listener, ok := listenerInterface.(core.ProtocolListener)
	if !ok {
		log.Printf("❌ [监听器管理] 监听器类型断言失败: 隧道ID=%s", tunnelID)
		return
	}

	// 停止监听器
	if err := tm.protocolFactory.StopListener(listener); err != nil {
		log.Printf("❌ [监听器管理] 停止监听器失败: %v", err)
		return
	}

	log.Printf("✅ [监听器管理] 监听器已停止: 隧道ID=%s", tunnelID)
}

// GetProtocolListener 获取协议监听器
func (tm *TunnelManager) GetProtocolListener(tunnelID string) core.ProtocolListener {
	tm.listenerMutex.RLock()
	defer tm.listenerMutex.RUnlock()

	listenerInterface, exists := tm.protocolListeners[tunnelID]
	if !exists {
		return nil
	}

	listener, ok := listenerInterface.(core.ProtocolListener)
	if !ok {
		return nil
	}

	return listener
}

// GetProtocolListenerStats 获取监听器统计信息
func (tm *TunnelManager) GetProtocolListenerStats(tunnelID string) *core.ProtocolStats {
	listener := tm.GetProtocolListener(tunnelID)
	if listener == nil {
		return nil
	}

	// 如果监听器实现了GetStats方法，调用它
	type statsProvider interface {
		GetStats() core.ProtocolStats
	}

	if sp, ok := listener.(statsProvider); ok {
		stats := sp.GetStats()
		return &stats
	}

	return nil
}
